import { ref, computed } from 'vue'

/**
 * Z-score标准化打分
 * 用于综合评分指标的标准化计算
 */
export function useScoreCalculation() {
  
  /**
   * 计算数组的平均值
   * @param {Array<number>} values - 数值数组
   * @returns {number} 平均值
   */
  const calculateMean = (values) => {
    if (!values || values.length === 0) return 0
    const sum = values.reduce((acc, val) => acc + val, 0)
    return sum / values.length
  }

  /**
   * 计算数组的标准差
   * @param {Array<number>} values - 数值数组
   * @param {number} mean - 平均值
   * @returns {number} 标准差
   */
  const calculateStdDev = (values, mean) => {
    if (!values || values.length === 0) return 0
    const squaredDiffs = values.map(val => Math.pow(val - mean, 2))
    const variance = squaredDiffs.reduce((acc, val) => acc + val, 0) / values.length
    return Math.sqrt(variance)
  }

  /**
   * 计算Z-score
   * @param {number} value - 原始值
   * @param {number} mean - 平均值
   * @param {number} stdDev - 标准差
   * @returns {number} Z-score值
   */
  const calculateZScore = (value, mean, stdDev) => {
    if (stdDev === 0) return 0
    return (value - mean) / stdDev
  }

  /**
   * 将Z-score转换为75-100分制
   * Z-score通常在-3到+3之间，我们将其映射到75-100
   * @param {number} zScore - Z-score值
   * @param {boolean} isPositive - 是否为正向指标（越大越好）
   * @param {string} indicatorKey - 指标key，用于特殊处理
   * @param {number} originalValue - 原始值，用于不良贷款增幅的特殊判断
   * @returns {number} 75-100分制的得分
   */
  const zScoreToScore = (zScore, isPositive = true, indicatorKey = null, originalValue = null) => {
    // 特殊处理：不良贷款增幅使用分档评分规则
    if (indicatorKey === 'badLoanGrowth' && originalValue !== null) {
      console.log(`[不良贷款增幅评分] 原始值=${originalValue}, Z-score=${zScore}`)
      
      // 【卓越 Excellent】不良贷款增幅 < 0 → 100分
      // 结果导向的最高奖励：成功压降不良贷款
      if (originalValue < 0) {
        console.log(`[不良贷款增幅评分] 卓越(Excellent)：增幅为负，得分=100`)
        return 100
      }
      
      // 【危险 Danger】Z-score > 1 → 0分
      // 风险管理的"熔断机制"：表现异常差，失控迹象
      if (zScore > 1) {
        console.log(`[不良贷款增幅评分] 危险(Danger)：Z-score>1，得分=0`)
        return 0
      }
      
      // 【预警 Warning】0 < Z-score <= 1 → 30分
      // 显著的惩罚信号：劣于平均水平
      if (zScore > 0 && zScore <= 1) {
        console.log(`[不良贷款增幅评分] 预警(Warning)：0<Z-score<=1，得分=30`)
        return 30
      }
      
      // 【关注 Attention】Z-score = 0 → 60分
      // 荣辱分界线：等于平均水平
      if (zScore === 0) {
        console.log(`[不良贷款增幅评分] 关注(Attention)：Z-score=0，得分=60`)
        return 60
      }
      
      // 【良好 Good】不良贷款增幅 >= 0 AND Z-score < 0 → 70分
      // 承认相对优势：风险在增加但好于平均
      if (originalValue >= 0 && zScore < 0) {
        console.log(`[不良贷款增幅评分] 良好(Good)：增幅>=0且Z-score<0，得分=70`)
        return 70
      }
      
      // 兜底：理论上不应该到这里
      console.log(`[不良贷款增幅评分] 未匹配任何规则，使用默认得分=60`)
      return 60
    }
    
    // 特殊处理：关注类贷款增幅使用"熔断机制"
    if (indicatorKey === 'concernLoanGrowth' && originalValue !== null) {
      console.log(`[关注类贷款增幅评分] 原始值=${originalValue}, Z-score=${zScore}`)
      
      // 【熔断机制】Z-score > 1 → 0分
      // 风险预警：关注类贷款增长过快，表示潜在风险大幅上升
      if (zScore > 1) {
        console.log(`[关注类贷款增幅评分] 熔断机制触发：Z-score>1，得分=0`)
        return 0
      }
      
      // 其他情况按正常规则打分
      console.log(`[关注类贷款增幅评分] Z-score<=1，按正常规则打分`)
    }
    
    // 特殊处理：增长类指标使用"优秀激励+地板惩罚"规则
    // 适用指标：新增贷款投放额、中间业务收入增长率、贷款户数增长率、存款余额增加值
    const growthIncentiveIndicators = ['newLoanAmount', 'intermediateIncomeGrowth', 'loanAccountGrowth', 'depositIncrease']
    if (growthIncentiveIndicators.includes(indicatorKey) && originalValue !== null) {
      const indicatorNameMap = {
        'newLoanAmount': '新增贷款投放额',
        'intermediateIncomeGrowth': '中间业务收入增长率',
        'loanAccountGrowth': '贷款户数增长率',
        'depositIncrease': '存款余额增加值'
      }
      const indicatorName = indicatorNameMap[indicatorKey] || indicatorKey
      console.log(`[${indicatorName}评分] 原始值=${originalValue}, Z-score=${zScore}`)
      
      // 【地板惩罚】原始值 < 0 → 0分
      // 负增长，直接给予0分惩罚
      if (originalValue < 0) {
        console.log(`[${indicatorName}评分] 地板惩罚：原始值<0(负增长)，得分=0`)
        return 0
      }
      
      // 【优秀激励】Z-score > 1 → 100分
      // 表现远超平均水平，给予满分奖励
      if (zScore > 1) {
        console.log(`[${indicatorName}评分] 优秀激励：Z-score>1，得分=100`)
        return 100
      }
      
      // 其他情况（原始值>=0且Z-score<=1）按正常zscore打分
      console.log(`[${indicatorName}评分] 按正常zscore打分`)
    }
    
    // 特殊处理：存款余额增速、稳定型中收增长率
    // 规则：负数且zscore>1或<-1时得0分，其他情况按正常zscore打分
    const negativeZeroIndicators = ['depositGrowth', 'stableIncomeGrowth']
    if (negativeZeroIndicators.includes(indicatorKey) && originalValue !== null) {
      console.log(`[${indicatorKey}评分] 原始值=${originalValue}, Z-score=${zScore}`)
      
      // 如果原始值为负数，且Z-score > 1 或 Z-score < -1，得分为0
      if (originalValue < 0 && (zScore > 1 || zScore < -1)) {
        console.log(`[${indicatorKey}评分] 原始值为负数且Z-score超出[-1,1]区间，得分=0`)
        return 0
      }
      
      // 其他情况（正数，或负数但Z-score在[-1,1]区间内）按正常zscore打分
      console.log(`[${indicatorKey}评分] 按正常zscore打分`)
    }
    
    // 默认：限制Z-score在-3到+3之间
    let limitedZScore = Math.max(-3, Math.min(3, zScore))
    
    if (!isPositive) {
      // 负向指标：Z-score越小越好，需要反转
      limitedZScore = -limitedZScore
    }
    
    // 默认：将-3到+3映射到80-100
    // Z-score = 0 时，得分 = 90 (平均水平)
    // Z-score = +3 时，得分 = 100 (最好)
    // Z-score = -3 时，得分 = 80 (最低分)
    const score = ((limitedZScore + 3) / 6) * 20 + 80
    
    return Math.round(score * 100) / 100 // 保留2位小数
  }

  /**
   * 从数据结果中提取数值
   * @param {Object} data - 指标数据
   * @param {string} type - 数据类型
   * @param {string} key - 指标key
   * @returns {number|null} 提取的数值
   * 
   * 数据行字段顺序（与 useComprehensiveScore.js 中的 SQL 查询对应）：
   * row[0] = buss_dt      (业务日期)
   * row[1] = index_nm     (指标名称)
   * row[2] = org_no       (机构号)
   * row[3] = index_value  (指标值) ⭐ 主要使用
   * row[4] = ori          (来源)
   */
  const extractValue = (data, type, key) => {
    try {
      // 关注类贷款指标：如果没有数据，说明不存在关注类贷款，返回0
      const concernLoanKeys = ['concernLoanRatio', 'concernLoanBalance', 'concernLoanGrowth']
      // 贷款迁徙率指标：如果没有数据，说明不存在对应类别的贷款，返回0
      const migrationRateKeys = ['normalLoanMigrationRate', 'specialMentionLoanMigrationRate', 'substandardLoanMigrationRate', 'doubtfulLoanMigrationRate']
      
      const zeroValueKeys = [...concernLoanKeys, ...migrationRateKeys]
      
      if (zeroValueKeys.includes(key)) {
        if (!data || !data.success) {
          return 0
        }
      } else {
        if (!data || !data.success) return null
      }

      switch (type) {
        case 'single':
        case 'multiple':
          // 单值或多值型：取第一个值的index_value（第4列）
          if (data.result?.datas && data.result.datas.length > 0 && data.result.datas[0] && data.result.datas[0][3] !== undefined) {
            const value = parseFloat(data.result.datas[0][3])
            // 关注类贷款指标和迁徙率指标：如果值无效（NaN），返回0
            if (isNaN(value) && zeroValueKeys.includes(key)) {
              return 0
            }
            return isNaN(value) ? null : value
          }
          // 关注类贷款指标和迁徙率指标：如果没有数据，返回0
          if (zeroValueKeys.includes(key)) {
            return 0
          }
          break

        case 'growth':
          // 增长型：计算增长率 = (期末 - 期初) / 期初 * 100
          // 支持多条记录求和（如稳定型中收）
          if (data.endResult?.datas && data.endResult.datas.length > 0 && 
              data.startResult?.datas && data.startResult.datas.length > 0) {
            const endValue = data.endResult.datas.reduce((sum, row) => {
              const val = parseFloat(row[3] || 0)
              return sum + (isNaN(val) ? 0 : val)
            }, 0)
            const startValue = data.startResult.datas.reduce((sum, row) => {
              const val = parseFloat(row[3] || 0)
              return sum + (isNaN(val) ? 0 : val)
            }, 0)
            if (!isNaN(endValue) && !isNaN(startValue) && startValue !== 0) {
              return ((endValue - startValue) / startValue) * 100
            }
          } else {
            // 关注类贷款增幅：如果数据不完整，直接返回0（正常情况，表示没有关注类贷款）
            if (zeroValueKeys.includes(key)) {
              console.debug(`[评分计算] ${key} 数据不完整，返回0（正常：该机构可能没有此类贷款）`)
              return 0
            }
            // 其他增长型指标：数据不完整时打印警告
            console.warn(`[评分计算] ${key} 增长型数据不完整:`, {
              hasEndResult: !!data.endResult?.datas,
              endResultLength: data.endResult?.datas?.length || 0,
              hasStartResult: !!data.startResult?.datas,
              startResultLength: data.startResult?.datas?.length || 0
            })
          }
          // 关注类贷款增幅和迁徙率指标：如果没有数据，返回0
          if (zeroValueKeys.includes(key)) {
            return 0
          }
          break

        case 'increase':
          // 增加值型：计算绝对增加额 = 期末 - 期初
          // 支持多条记录求和（如稳定型中收）
          if (data.endResult?.datas && data.endResult.datas.length > 0 && 
              data.startResult?.datas && data.startResult.datas.length > 0) {
            const endValue = data.endResult.datas.reduce((sum, row) => {
              const val = parseFloat(row[3] || 0)
              return sum + (isNaN(val) ? 0 : val)
            }, 0)
            const startValue = data.startResult.datas.reduce((sum, row) => {
              const val = parseFloat(row[3] || 0)
              return sum + (isNaN(val) ? 0 : val)
            }, 0)
            if (!isNaN(endValue) && !isNaN(startValue)) {
              return endValue - startValue
            }
          } else {
            console.warn(`[评分计算] ${key} 增加值型数据不完整:`, {
              hasEndResult: !!data.endResult?.datas,
              endResultLength: data.endResult?.datas?.length || 0,
              hasStartResult: !!data.startResult?.datas,
              startResultLength: data.startResult?.datas?.length || 0
            })
          }
          break

        case 'growthWithWriteOff':
          // 带核销的增长型：计算增长率 = (期末 + 核销 - 期初) / 期初 * 100
          // 注意：核销数据可能不存在（没有核销记录），此时核销金额为0
          if (data.endResult?.datas && data.endResult.datas.length > 0 && 
              data.startResult?.datas && data.startResult.datas.length > 0) {
            const endValue = data.endResult.datas.reduce((sum, row) => {
              const val = parseFloat(row[3] || 0)
              return sum + (isNaN(val) ? 0 : val)
            }, 0)
            const startValue = data.startResult.datas.reduce((sum, row) => {
              const val = parseFloat(row[3] || 0)
              return sum + (isNaN(val) ? 0 : val)
            }, 0)
            // 如果没有核销记录，核销金额为0
            const writeOffValue = (data.writeOffResult?.datas && data.writeOffResult.datas.length > 0) 
              ? data.writeOffResult.datas.reduce((sum, row) => {
                  const val = parseFloat(row[3] || 0)
                  return sum + (isNaN(val) ? 0 : val)
                }, 0)
              : 0
            if (!isNaN(endValue) && !isNaN(startValue) && !isNaN(writeOffValue)) {
              // 特殊情况：如果期初为0，期末不为0，返回一个极大的增长率（如999%），表示从无到有
              if (startValue === 0) {
                if (endValue + writeOffValue > 0) {
                  console.log(`[不良贷款增幅] 期初为0，期末+核销=${endValue + writeOffValue}，返回999%`)
                  return 999  // 从无到有，视为极大增幅
                } else {
                  // 期初期末都是0，增幅为0
                  return 0
                }
              }
              return ((endValue + writeOffValue - startValue) / startValue) * 100
            }
          }
          break

        case 'ratio':
          // 比率型：计算分子/分母
          if (data.numeratorResult?.datas && data.denominatorResult?.datas) {
            const numerator = data.numeratorResult.datas.reduce((sum, row) => {
              return sum + parseFloat(row[3] || 0)
            }, 0)
            const denominator = data.denominatorResult.datas.reduce((sum, row) => {
              return sum + parseFloat(row[3] || 0)
            }, 0)
            if (denominator !== 0) {
              const ratio = numerator / denominator
              // 检查是否有单位标记
              if (data.unit === 'wan') {
                // 人均利润：转换为万元
                return ratio / 10000
              } else {
                // 其他比率型指标：转换为百分比
                return ratio * 100
              }
            }
          }
          break

        case 'deviation':
          // 偏离度型：计算(月末余额 - 月日均余额) / 月末余额 * 100
          if (data.monthEndResult?.datas && data.monthAvgResult?.datas) {
            const monthEnd = parseFloat(data.monthEndResult.datas[0][3])
            const monthAvg = data.monthAvgResult.datas.reduce((sum, row) => {
              return sum + parseFloat(row[3] || 0)
            }, 0)
            if (!isNaN(monthEnd) && !isNaN(monthAvg) && monthEnd !== 0) {
              return ((monthEnd - monthAvg) / monthEnd) * 100
            }
          }
          break
      }
    } catch (error) {
      console.error('[评分计算] 提取数值失败:', error)
    }
    return null
  }

  /**
   * 指标配置：定义每个指标的正负向及权重
   */
  const indicatorConfig = {
    badLoanRate: { name: '不良贷款率', isPositive: false, weight: 2 },
    badLoanBalance: { name: '不良贷款余额', isPositive: false, weight: 2 },
    badLoanGrowth: { name: '不良贷款增幅', isPositive: false, weight: 6 },
    normalLoanMigrationRate: { name: '正常类贷款迁徙率', isPositive: false, weight: 1.5 },
    specialMentionLoanMigrationRate: { name: '关注类贷款迁徙率', isPositive: false, weight: 2.5 },
    substandardLoanMigrationRate: { name: '次级类贷款迁徙率', isPositive: false, weight: 0.5 },
    doubtfulLoanMigrationRate: { name: '可疑类贷款迁徙率', isPositive: false, weight: 0.5 },
    top10LoanRatio: { name: 'Top10客户贷款占比', isPositive: false, weight: 2.5 },
    top10LoanBalance: { name: 'Top10客户贷款余额', isPositive: false, weight: 2.5 },
    overdue90DayRatio: { name: '逾期90天不良贷款余额占比', isPositive: false, weight: 5 },
    concernLoanBalance: { name: '关注类贷款余额', isPositive: false, weight: 1 },
    concernLoanGrowth: { name: '关注类贷款增幅', isPositive: false, weight: 3 },
    concernLoanRatio: { name: '关注类贷款占比', isPositive: false, weight: 1 },
    depositGrowth: { name: '存款余额增速', isPositive: true, weight: 2.5 },
    depositIncrease: { name: '存款余额增加值', isPositive: true, weight: 2.5 },
    lowCostDepositRatio: { name: '低成本存款占比', isPositive: true, weight: 5 },
    depositDeviation: { name: '存款偏离度', isPositive: false, weight: 5 },
    newLoanAmount: { name: '新增贷款投放额', isPositive: true, weight: 4 },
    totalLoan: { name: '各项贷款', isPositive: true, weight: 4 },
    loanAccountIncrease: { name: '贷款户数增加值', isPositive: true, weight: 3.5 },
    loanAccountGrowth: { name: '贷款户数增长率', isPositive: true, weight: 3.5 },
    intermediateIncomeAmount: { name: '中间业务收入绝对额', isPositive: true, weight: 2 },
    intermediateIncomeRatio: { name: '中间业务收入占比', isPositive: true, weight: 2 },
    intermediateIncomeGrowth: { name: '中间业务收入增长率', isPositive: true, weight: 2 },
    stableIncomeRatio: { name: '稳定型中收占比', isPositive: true, weight: 1 },
    stableIncomeAmount: { name: '稳定型中收绝对额', isPositive: true, weight: 2 },
    stableIncomeGrowth: { name: '稳定型中收增长率', isPositive: true, weight: 1 },
    profitPerCapita: { name: '人均利润', isPositive: true, weight: 5 },
    costIncomeRatio: { name: '成本收入比', isPositive: false, weight: 5 },
    riskComplianceScore: { name: '风险合规得分', isPositive: true, weight: 20 }
  }

  /**
   * 为所有支行的所有指标计算Z-score得分
   * @param {Object} scoreData - 所有支行的数据
   * @param {Object} indicators - 指标配置
   * @returns {Object} 包含得分的数据
   */
  const calculateAllScores = (scoreData, indicators) => {
    console.log('[评分计算] 开始计算Z-score得分...')
    
    const result = {
      branches: {}, // 每个支行的得分
      statistics: {} // 每个指标的统计信息
    }

    // 1. 按指标收集所有支行的数值
    const indicatorValues = {}
    
    Object.entries(indicators).forEach(([key, config]) => {
      indicatorValues[key] = {
        values: [],
        orgNos: [],
        config: config
      }
    })

    // 遍历所有支行，收集数据
    Object.entries(scoreData).forEach(([orgNo, branchData]) => {
      Object.entries(indicators).forEach(([key, config]) => {
        const data = branchData[key]
        if (data) {
          const value = extractValue(data, config.type, key)
          if (value !== null && !isNaN(value)) {
            indicatorValues[key].values.push(value)
            indicatorValues[key].orgNos.push(orgNo)
          }
        }
      })
    })

    // 2. 计算每个指标的统计信息（平均值、标准差）
    Object.entries(indicatorValues).forEach(([key, data]) => {
      if (data.values.length > 0) {
        const mean = calculateMean(data.values)
        const stdDev = calculateStdDev(data.values, mean)
        
        result.statistics[key] = {
          name: indicatorConfig[key].name,
          count: data.values.length,
          mean: Math.round(mean * 100) / 100,
          stdDev: Math.round(stdDev * 100) / 100,
          min: Math.min(...data.values),
          max: Math.max(...data.values),
          isPositive: indicatorConfig[key].isPositive
        }

        console.log(`[评分计算] ${indicatorConfig[key].name}: 均值=${mean.toFixed(2)}, 标准差=${stdDev.toFixed(2)}`)
      }
    })

    // 3. 为每个支行的每个指标计算Z-score得分
    Object.entries(scoreData).forEach(([orgNo, branchData]) => {
      result.branches[orgNo] = {
        scores: {},
        weightedScore: 0,  // 加权得分
        totalWeight: 0     // 总权重
      }

      Object.entries(indicators).forEach(([key, config]) => {
        const data = branchData[key]
        const stats = result.statistics[key]
        
        if (data && stats) {
          const value = extractValue(data, config.type, key)
          
          if (value !== null && !isNaN(value)) {
            const zScore = calculateZScore(value, stats.mean, stats.stdDev)
            const score = zScoreToScore(zScore, indicatorConfig[key].isPositive, key, value)
            const weight = indicatorConfig[key].weight || 1
            
            // 计算加权得分
            const weightedScore = score * weight / 100
            
            result.branches[orgNo].scores[key] = {
              name: indicatorConfig[key].name,
              originalValue: Math.round(value * 100) / 100,
              zScore: Math.round(zScore * 100) / 100,
              score: score,
              weight: weight,
              weightedScore: weightedScore,  // 添加加权得分字段
              isPositive: indicatorConfig[key].isPositive
            }
            
            // 累加加权得分
            result.branches[orgNo].weightedScore += weightedScore
            result.branches[orgNo].totalWeight += weight
          } else {
            // 调试：记录哪些支行哪些指标没有有效数值
            if (key === 'badLoanGrowth') {
              console.log(`[评分计算] ${orgNo} 的 ${indicatorConfig[key]?.name || key} 没有有效数值: value=${value}`)
            }
          }
        } else {
          // 调试：记录哪些支行哪些指标缺少数据或统计信息
          if (key === 'badLoanGrowth') {
            console.log(`[评分计算] ${orgNo} 的 ${indicatorConfig[key]?.name || key} 缺少数据或统计信息: data=${!!data}, stats=${!!stats}`)
          }
        }
      })

      // 计算加权平均得分
      if (result.branches[orgNo].totalWeight > 0) {
        result.branches[orgNo].averageScore = Math.round(
          (result.branches[orgNo].weightedScore / result.branches[orgNo].totalWeight) * 100
        ) / 100
      } else {
        result.branches[orgNo].averageScore = 0
      }
    })

    // 4. 计算每个指标的排名
    Object.entries(indicators).forEach(([key, config]) => {
      // 收集所有支行在该指标上的得分
      const indicatorScores = []
      Object.entries(result.branches).forEach(([orgNo, branchData]) => {
        if (branchData.scores[key]) {
          indicatorScores.push({
            orgNo,
            score: branchData.scores[key].score
          })
        }
      })

      // 按得分降序排序
      indicatorScores.sort((a, b) => b.score - a.score)

      // 为每个支行在该指标上分配排名
      indicatorScores.forEach((item, index) => {
        if (result.branches[item.orgNo].scores[key]) {
          result.branches[item.orgNo].scores[key].rank = index + 1
        }
      })
    })

    // 5. 计算支行综合排名（基于加权得分总和）
    const branchScores = Object.entries(result.branches)
      .map(([orgNo, data]) => ({
        orgNo,
        weightedScore: data.weightedScore
      }))
      .sort((a, b) => b.weightedScore - a.weightedScore)

    branchScores.forEach((item, index) => {
      result.branches[item.orgNo].rank = index + 1
    })

    console.log(`[评分计算] 计算完成，共 ${Object.keys(result.branches).length} 个支行`)
    
    return result
  }

  return {
    calculateMean,
    calculateStdDev,
    calculateZScore,
    zScoreToScore,
    extractValue,
    calculateAllScores,
    indicatorConfig
  }
}

